home *** CD-ROM | disk | FTP | other *** search
/ Die Speccy' 97 / Die Speccy' 97.iso / amiga_system / the_aminet / comm / bbs / wwbbs31_source.lha / WWBBS / Library / files.c < prev    next >
C/C++ Source or Header  |  1994-11-06  |  7KB  |  313 lines
  1. #include "wwbbs.h"
  2. #include "files.h"
  3.  
  4. __asm
  5. APTR OpenFileGroup(register __a0 BYTE *path,register __a1 BYTE *name,register __d0 LONG type)
  6.     {
  7.         APTR ret=NULL;
  8.         BYTE group[41],directory[256];
  9.         strcpy(group,"");
  10.         strcpy(directory,"");
  11.         if(GetConfigTags(CFGTAG_Path,path,CFGTAG_Name,name,FBTAG_Group,group,FBTAG_Directory,directory,TAG_END))
  12.             {
  13.                 if(strlen(group) && strlen(directory))
  14.                     {
  15.                         struct FileGroupNode *gnode;
  16.                         {
  17.                             BOOL exists=FALSE;
  18.                             ObtainSemaphoreShared(&FileGroupSemaphore);
  19.                             if(FindName(&FileGroupList,group))
  20.                                 exists=TRUE;
  21.                             ReleaseSemaphore(&FileGroupSemaphore);
  22.                             if(!exists)
  23.                                 LoadFileGroup(group,directory);
  24.                         }
  25.                         ObtainSemaphoreShared(&FileGroupSemaphore);
  26.                         if(gnode=(struct FileGroupNode *) FindName(&FileGroupList,group))
  27.                             {
  28.                                 if(type==EXCLUSIVE_LOCK)
  29.                                     ObtainSemaphore(&gnode->fgn_Semaphore);
  30.                                 else
  31.                                     ObtainSemaphoreShared(&gnode->fgn_Semaphore);
  32.                                 ObtainSemaphore(&gnode->fgn_UsageCountSemaphore);
  33.                                 gnode->fgn_UsageCount++;
  34.                                 ReleaseSemaphore(&gnode->fgn_UsageCountSemaphore);
  35.                                 ret=gnode;
  36.                             }
  37.                         else
  38.                             ReleaseSemaphore(&FileGroupSemaphore);
  39.                     }
  40.             }
  41.         return(ret);
  42.     }
  43.  
  44. __asm
  45. void CloseFileGroup(register __a0 struct FileGroupNode *gnode)
  46.     {
  47.         ObtainSemaphore(&gnode->fgn_UsageCountSemaphore);
  48.         gnode->fgn_UsageCount--;
  49.         ReleaseSemaphore(&gnode->fgn_UsageCountSemaphore);
  50.         ReleaseSemaphore(&gnode->fgn_Semaphore);
  51.         ReleaseSemaphore(&FileGroupSemaphore);
  52.     }
  53.  
  54. __asm
  55. BOOL GetFileGroupDirectory(register __a0 struct FileGroupNode *gnode,register __a1 BYTE *buffer,register __d0 LONG len)
  56.     {
  57.         return((BOOL) ((NameFromLock(gnode->fgn_Directory,buffer,len)) ? TRUE : FALSE));
  58.     }
  59.  
  60. __asm
  61. ULONG GetFile(register __a0 struct FileGroupNode *gnode,register __a1 struct TagItem *tags_orig)
  62.     {
  63.         ULONG ret=0;
  64.         ULONG id=0;
  65.         BOOL exists=FALSE;
  66.         {
  67.             struct TagItem *tags;
  68.             if(tags=CloneTagItems(tags_orig))
  69.                 {
  70.                     if(FilterTagItems(tags,file_get_tags,TAGFILTER_AND))
  71.                         {
  72.                             struct TagItem *tstate,*tag;
  73.                             APTR data;
  74.                             tstate=tags;
  75.                             while(tag=NextTagItem(&tstate))
  76.                                 {
  77.                                     data=(APTR) tag->ti_Data;
  78.                                     switch(tag->ti_Tag)
  79.                                         {
  80.                                             case FILTAG_ID:
  81.                                                 id=(ULONG) data;
  82.                                                 break;
  83.                                             case FILTAG_Exists:
  84.                                                 exists=(BOOL) data;
  85.                                                 break;
  86.                                         }
  87.                                 }
  88.                         }
  89.                     FreeTagItems(tags);
  90.                 }
  91.         }
  92.         {
  93.             if(id)
  94.                 {
  95.                     struct FileNode *node=NULL;
  96.                     if(node=GetFileNode(gnode,id))
  97.                         {
  98.                             if(exists) ret++;
  99.                             ret+=GetFileFields(node,tags_orig);
  100.                         }
  101.                 }
  102.         }
  103.         return(ret);
  104.     }
  105.  
  106. ULONG GetFileTags(struct FileGroupNode *gnode,Tag tag,...)
  107.     {
  108.         return(GetFile(gnode,(struct TagItem *) &tag));
  109.     }
  110.  
  111. __asm
  112. ULONG SetFile(register __a0 struct FileGroupNode *gnode,register __a1 struct TagItem *tags_orig)
  113.     {
  114.         ULONG ret=0;
  115.         ULONG id=0;
  116.         BOOL forcesave=FALSE,dontsave=FALSE;
  117.         {
  118.             struct TagItem *tags;
  119.             if(tags=CloneTagItems(tags_orig))
  120.                 {
  121.                     if(FilterTagItems(tags,file_set_tags,TAGFILTER_AND))
  122.                         {
  123.                             struct TagItem *tstate,*tag;
  124.                             APTR data;
  125.                             tstate=tags;
  126.                             while(tag=NextTagItem(&tstate))
  127.                                 {
  128.                                     data=(APTR) tag->ti_Data;
  129.                                     switch(tag->ti_Tag)
  130.                                         {
  131.                                             case FILTAG_ID:
  132.                                                 id=(ULONG) data;
  133.                                                 break;
  134.                                             case FILTAG_ForceSave:
  135.                                                 forcesave=(BOOL) data;
  136.                                                 break;
  137.                                             case FILTAG_DontSave:
  138.                                                 dontsave=(BOOL) data;
  139.                                                 break;
  140.                                         }
  141.                                 }
  142.                         }
  143.                     FreeTagItems(tags);
  144.                 }
  145.         }
  146.         {
  147.             if(id)
  148.                 {
  149.                     struct FileNode *node=NULL;
  150.                     if(node=GetFileNode(gnode,id))
  151.                         ret+=SetFileFields(node,tags_orig);
  152.                 }
  153.         }
  154.         if((ret && !dontsave) || forcesave)
  155.             SaveFileGroup(gnode);
  156.         return(ret);
  157.     }
  158.  
  159. ULONG SetFileTags(struct FileGroupNode *gnode,Tag tag,...)
  160.     {
  161.         return(SetFile(gnode,(struct TagItem *) &tag));
  162.     }
  163.  
  164. __asm
  165. ULONG AddFile(register __a0 struct FileGroupNode *gnode,register __a1 struct TagItem *tags_orig)
  166.     {
  167.         ULONG ret=0;
  168.         BOOL dontsave=FALSE;
  169.         {
  170.             struct TagItem *tags;
  171.             if(tags=CloneTagItems(tags_orig))
  172.                 {
  173.                     if(FilterTagItems(tags,file_add_tags,TAGFILTER_AND))
  174.                         {
  175.                             struct TagItem *tstate,*tag;
  176.                             APTR data;
  177.                             tstate=tags;
  178.                             while(tag=NextTagItem(&tstate))
  179.                                 {
  180.                                     data=(APTR) tag->ti_Data;
  181.                                     switch(tag->ti_Tag)
  182.                                         {
  183.                                             case FILTAG_DontSave:
  184.                                                 dontsave=(BOOL) data;
  185.                                                 break;
  186.                                         }
  187.                                 }
  188.                         }
  189.                     FreeTagItems(tags);
  190.                 }
  191.         }
  192.         {
  193.             struct FileNode *node;
  194.             if(node=AllocVec(sizeof(struct FileNode),MEMF_CLEAR))
  195.                 {
  196.                     node->fn_ID=gnode->fgn_FileCount+1;
  197.                     DateStamp(&node->fn_Date);
  198.                     AddTail(&gnode->fgn_Files,(struct Node *) node);
  199.                     gnode->fgn_FileCount++;
  200.                     ret=node->fn_ID;
  201.                 }
  202.         }
  203.         if(ret && !dontsave)
  204.             SaveFileGroup(gnode);
  205.         return(ret);
  206.     }
  207.  
  208. ULONG AddFileTags(struct FileGroupNode *gnode,Tag tag,...)
  209.     {
  210.         return(AddFile(gnode,(struct TagItem *) &tag));
  211.     }
  212.  
  213. __asm
  214. BOOL RemFile(register __a0 struct FileGroupNode *gnode,register __a1 struct TagItem *tags_orig)
  215.     {
  216.         BOOL ret=FALSE;
  217.         ULONG id=0;
  218.         BOOL dontsave=FALSE;
  219.         {
  220.             struct TagItem *tags;
  221.             if(tags=CloneTagItems(tags_orig))
  222.                 {
  223.                     if(FilterTagItems(tags,file_rem_tags,TAGFILTER_AND))
  224.                         {
  225.                             struct TagItem *tstate,*tag;
  226.                             APTR data;
  227.                             tstate=tags;
  228.                             while(tag=NextTagItem(&tstate))
  229.                                 {
  230.                                     data=(APTR) tag->ti_Data;
  231.                                     switch(tag->ti_Tag)
  232.                                         {
  233.                                             case FILTAG_ID:
  234.                                                 id=(ULONG) data;
  235.                                                 break;
  236.                                             case FILTAG_DontSave:
  237.                                                 dontsave=(BOOL) data;
  238.                                                 break;
  239.                                         }
  240.                                 }
  241.                         }
  242.                     FreeTagItems(tags);
  243.                 }
  244.         }
  245.         {
  246.             struct FileNode *node;
  247.             if(node=GetFileNode(gnode,id))
  248.                 {
  249.                     Remove((struct Node *) node);
  250.                     FreeVec(node);
  251.                     ret=TRUE;
  252.                 }
  253.         }
  254.         if(ret && !dontsave)
  255.             SaveFileGroup(gnode);
  256.         return(ret);
  257.     }
  258.  
  259. BOOL RemFileTags(struct FileGroupNode *gnode,Tag tag,...)
  260.     {
  261.         return(RemFile(gnode,(struct TagItem *) &tag));
  262.     }
  263.  
  264. __asm
  265. ULONG GetNextFile(register __a0 struct FileGroupNode *gnode,register __d0 ULONG id)
  266.     {
  267.         ULONG ret=0;
  268.         struct FileNode *node;
  269.         if(node=GetFileNode(gnode,id))
  270.             {
  271.                 node=(struct FileNode *) node->fn_Node.ln_Succ;
  272.                 if(node->fn_Node.ln_Succ)
  273.                     ret=node->fn_ID;
  274.             }
  275.         else
  276.             {
  277.                 for(node=(struct FileNode *) gnode->fgn_Files.lh_Head;node->fn_Node.ln_Succ;node=(struct FileNode *) node->fn_Node.ln_Succ)
  278.                     {
  279.                         if(node->fn_ID>id)
  280.                             {
  281.                                 ret=node->fn_ID;
  282.                                 break;
  283.                             }
  284.                     }
  285.             }
  286.         return(ret);
  287.     }
  288.  
  289. __asm
  290. ULONG GetPreviousFile(register __a0 struct FileGroupNode *gnode,register __d0 ULONG id)
  291.     {
  292.         ULONG ret=0;
  293.         struct FileNode *node;
  294.         if(node=GetFileNode(gnode,id))
  295.             {
  296.                 node=(struct FileNode *) node->fn_Node.ln_Pred;
  297.                 if(node->fn_Node.ln_Pred)
  298.                     ret=node->fn_ID;
  299.             }
  300.         else
  301.             {
  302.                 for(node=(struct FileNode *) gnode->fgn_Files.lh_TailPred;node->fn_Node.ln_Pred;node=(struct FileNode *) node->fn_Node.ln_Pred)
  303.                     {
  304.                         if(node->fn_ID<id)
  305.                             {
  306.                                 ret=node->fn_ID;
  307.                                 break;
  308.                             }
  309.                     }
  310.             }
  311.         return(ret);
  312.     }
  313.